# LeetCode 142、环形链表II

# 一、题目描述

给定一个链表,返回链表开始入环的第一个节点

如果链表无环,则返回 null。为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。

如果 pos 是 -1,则在该链表中没有环。

注意,pos 仅仅是用于标识环的情况,并不会作为参数传递到函数中。

说明:不允许修改给定的链表。

# 二、题目解析

1、通过快慢指针的方式,在环中寻找它们的第一次相遇的节点位置

2、当快慢指针相遇的时候:

img

x 代表从头节点到环形入口节点的节点数(不包含头节点)

y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)

z 代表从第一次相遇节点到环形入口的节点数(不包含第一次相遇节点)

此时,快指针走了 x + y + n (y + z),其中,x + y 表示快指针第一次到达相遇节点,n 代表快指针在环里面绕了多少圈。

而慢指针走了 x + y 步。

那么就出现了一个等式 x + y = [x + y + n (y + z)] / 2,即x = n(y + z)- y

n(y + z)- y 代表的含义是一个指针从相遇节点开始出发,走了 n 圈之后回到原来的出发位置,往后退 y 步

由于 x 代表从头节点到环形入口节点的节点数,并且x = n(y + z)- y,所以n(y + z)- y 代表的含义就是一个指针从相遇节点开始出发,走了 n 圈之后回到原来的出发位置,往后退 y 步来到了环的入口位置

那么,我们就可以设置两个指针,一个从链表的头节点开始出发,一个指针从相遇节点开始出发,当它们相遇的时候,代表着环的入口节点找到了。

补充:

  • 1、当 slow = 1 , fast = 2 ,为什么 fast 和 slow 一定会相遇?
  • 2、当 slow = 1 , fast = 2 ,fast 和 slow 相遇时,slow 指针是否绕环超过一圈?
  • 3、slow 和 fast 的移动步数有什么规则?
  • 4、能否设置为 slow 每次移动 1 步,fast 每次移动 3、4、5...步?
  • 5、为什么设置 slow = 1 , fast = 2 ?
  • 6、为什么得出相反的结论?

为了方便大家理解与表达,所以回答尽可能的采取口语化的表达方式,面试的时候你直接拿去用就行。

# 1、当 slow = 1 , fast = 2 ,为什么 fast 和 slow 一定会相遇?

首先,我们从现实角度去思考。

一个 400 米的圆形跑道上,有跑的慢的人、有跑的快的人,只要给予一定的时间,快的肯定会追上慢的,触发相遇。

环形链表在这个的基础上增加了一条限制:跑道并非连续,而是有一个个的节点组成的

需要注意,如果两者没有在节点相遇,而是在节点与节点之间的位置相遇,那并非相遇只是相交

1、假设,fast 在 slow 后方一个节点的位置,那么它们都跳一次之后,fast 和 slow 相遇了。

2、假设,fast 在 slow 后方两个节点的位置,那么它们都跳一次之后,fast 和 slow 的距离缩短为 1,变成了上述假设 1 的问题,可以相遇。

3、假设,fast 在 slow 后方 N 个节点的位置,那么它们都跳一次之后,fast 和 slow 的距离缩短为 N - 1,每条一次,都可以缩短一个单位,不断缩短,最终变成上述的假设 1。

所以,fast 和 slow 一定会相遇

# 2、当 slow = 1 , fast = 2 ,fast 和 slow 相遇时,slow 指针是否绕环超过一圈?

从 slow 进入环之后开始统计,fast 与 slow 相距最远的距离是 fast 在 slow 前方一个节点的位置。

img

此时,假设一下,fast 与 slow 同时在节点 2 开始出发,相当于两者相距一个环的距离。

img

当 slow 跑完一圈来到起始位置节点 2 时,由于 fast 速度是 slow 的两倍,那么 fast 必然跑了两圈也来到起始位置节点 2 ,两者相遇。

而此时,fast 在 slow 的前方位置,意味着两者的距离是小于一个完整的环的节点数的,说明 fast 可以更快的追上 slow。

既然 fast 与 slow 相距一个环的距离相遇时,slow 才能跑一圈,那么相距更短的距离,slow 没有跑完一圈,两者相遇了。

# 3、slow 和 fast 的移动步数有什么规则?

只需要两者的步数不一致就行。

# 4、能否设置为 slow 每次移动 1 步,fast 每次移动 3、4、5...步?

先说答案:可以

首先,只要快慢两个指针都进入环中,两者有速度差,快指针就一定能够追上慢指针。

追上可以分为两种情况:

1、恰好追上,即快慢指针在某个位置相遇了 2、快指针超过了慢指针,快指针跑到了慢指针的前面了

所以,我们需要分析的就是第二种情况:跑到前面之后能否多跑几圈之后刚好相遇

假设环的周长为整数 L,slow 每次走 a 步,fast 每次走 b 步,a ≠ b。

img

相遇时,两者都走了 t 次。

1、slow 走过的路程:x + y + n(y+z), n 代表 slow 绕了 n 圈 2、fast 走过的路程:x + y + m(y+z),m 代表 fast饶了 m 圈 3、m > n

对于 slow :x + y + n(y+z) = a * t

对于 fast :x + y + m(y+z) = b * t

两者一相减:

(m - n)( y + z ) = ( b - a ) * t

y + z 代表一圈的节点数,y + z = L

(m - n)L = ( b - a ) * t

b - a 为一个正整数,假设为 c 。

**t = (**m - n)L / c

其中 L 为常量,m 与 n 都可以随便设置,因此 m - n 的值可以为 1、2、3、。。。,

无论 c 取任何的正整数值,始终可以找到 m 与 n,计算得到一个正整数 t 。

也就是说 c 可以为 1、2、3、4、5。。。

说明 slow 与 fast 的速度差可以为 1、2、3、4、5。。。

由此也证明了 slow 每次走 1 步,fast 每次走 2 步、3 步、4 步。。。都是可以相遇的。

甚至,slow 每次走 2 步,fast 每次 3 步、4 步。。。都是可以相遇的。

只要 a ≠ b,存在步数差。

# 5、为什么设置 slow = 1 , fast = 2 ?

由于 **b - a = (**m - n)L / t

说明速度差 b - a 越小,fast 和 slow 跑的圈数就越小,经历的节点数也就越少,

由此 b – a = 1 是一个最小的答案,即 fast 和 slow 相差一步最合理

然后,再来看,slow 进环的时候,fast 已经在环里面了,当 slow 来到环入口的时候,代表 fast 已经快跑了一圈。

所以,fast 和 slow 相遇,m 至少为 1。

m 越小,fast 总共走的路程就越小,时间复杂度就越低。

所以,m = 1 时最低的时间复杂度。

所以,fast 跑的越慢,越能在环中少跑几圈等到还在外面直线跑的 slow。

由于 a ≠ b, b – a = 1 ,a = 1,所以 b = 2。

所以,设置 slow 为 1 ,fast 为 2 最合理!

# 6、为什么得出相反的结论?

关于 fast 与 slow 能否相遇的问题,我在网上看到这样的回答。

img

仔细看看,是不是很有道理,但得到的结论却和本文问题 4 得出的结论不符。

谁是对的呢?

我们顺着它的假设来模拟一下。

假设环的周长为偶数,也就是六个节点。

img

并且进入环后 slow = 1 ,fast = 3,slow 与 fast 的距离为奇数。

img

模拟一下,fast 始终会出现在节点 4 和节点 1 这两个位置,当 slow 重新来到节点 1 的时候,fast 又来到了节点 4,如此反复,两者无法相遇。

这个结论是对的??!!

这种假设根本就不会成立!

即进入环后 slow = 1 ,fast = 3,slow 与 fast 的距离为奇数这种假设无法成立。

在进入环之前,slow 和 fast 有一段公共的直线路需要走。

假设这条直线的长度为 m。

那么 slow 需要跳 m 次才能来到环入口位置节点 1 ,fast 需要跳 m/3 次才能第一次来到环入口位置节点 1,环的节点数是 6 个,fast 跑 2 次可以跑完一圈,假设跑了 n 圈,那么就跑了 2n 次,那么再跑一次就来到了节点 4 。

于是有了等式:m = m / 3 + 2n + 1

计算一下得 n = ( 2m / 3 - 1 ) / 2

由于 2m 为偶数,根据数学知识一个能被 3 整除的偶数除以 3 仍为偶数,于是 2m / 3 为偶数,2m / 3 - 1 为奇数, ( 2m / 3 - 1 ) / 2 无法是整数。

所以,找不到这样一个整数 m 和整数 n,使得上面的假设成立

假设不成立,结论也不成立!

# 三、参考代码

# 1、Java 代码

// 登录 AlgoMooc 官网获取更多算法图解
// https://www.algomooc.com
// 作者:程序员吴师兄
// 代码有看不懂的地方一定要私聊咨询吴师兄呀
// 环形链表 II ( LeetCode 142 ) : https://leetcode-cn.com/problems/linked-list-cycle-ii
public class Solution {
    public ListNode detectCycle(ListNode head) {
        
        // 1、通过快慢指针的方式,在环中寻找它们的第一次相遇的节点位置

        // 2、定义一个慢指针,每次只会向前移动 1 步
        ListNode slow = head;
        // 3、定义一个快指针,每次只会向前移动 2 步
        ListNode fast = head;

        // 4、如果链表有环,那么无论怎么移动,fast 指向的节点都是有值的
        while (fast != null && fast.next != null) {
            // 慢指针每次只会向前移动 1 步
            slow = slow.next;
            // 快指针每次只会向前移动 2 步
            fast = fast.next.next;

            // 快慢指针相遇,说明有环
            // x 代表从头节点到环形入口节点的节点数(不包含头节点)
            // y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)
            // z 代表从第一次相遇节点到环形入口的节点数(不包含第一次相遇节点)
            // y + z 代表环的节点总数
            // 此时,快指针走了 x + y + n (y + z)
            // 其中,x + y 表示快指针第一次到达相遇节点,n 代表快指针在环里面绕了多少圈
            // 此时,慢指针走了 x + y 步

            // 由于快指针每次走 2 步,所以快慢指针第一次相遇的时候出现一个等式
            // x + y = [x + y + n (y + z)] / 2
            // 即 2 * (x + y) = x + y + n (y + z)
            // 即 x + y = n(y + z)
            // 即 x = n(y + z)- y
            // 我们的目的就是去求 x
            
            // 定义两个指针,一个指向相遇节点,定义为 b,一个指向链表头节点,定义为 a

            // b 在环中绕圈圈,走了 n(y + z)步会回到原处,即回到相遇节点处
            // 由于 y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)
            // 所以 n(y + z) - y 时,b 到达了环形入口节点位置

            // 由于 x 代表从头节点到环形入口节点的节点数(不包含头节点)
            // 所以 a 走了 x 步时,a 到达了环形入口节点位置

            // 当 x = n(y + z)- y 时,找到了环形入口节点位置

            // 5、开始寻找环入口
            if (slow == fast) {

                // 定义两个指针,一个指向相遇节点,定义为 b,一个指向链表头节点,定义为 a
                // 一个指向相遇节点,定义为 b
                ListNode b = fast;

                // 一个指向链表头节点,定义为 a
                ListNode a = head;

                // 让 a 、b 两个指针向前移动,每次移动一步,直到相遇位置
                // 由于有环,必然相遇
                // 当 b 走了 n(y + z) - y 时,b 到达了环形入口节点位置
                // 当 a 走了 x 步时,a 到达了环形入口节点位置
                // a 与 b 相遇
                while (a != b) {
                    // a 指针每次只会向前移动 1 步
                    a = a.next;
                    // b 指针每次只会向前移动 1 步
                    b = b.next;
                }

                // 6、返回 a 和 b 相遇的节点位置就是环形入口节点位置
                return a;
            }
        }

        // 没有环,返回 null
        return null;
    }
}

# **2、**C++ 代码

// 登录 AlgoMooc 官网获取更多算法图解
// https://www.algomooc.com
// 作者:程序员吴师兄
// 代码有看不懂的地方一定要私聊咨询吴师兄呀
// 环形链表 II ( LeetCode 142 ) : https://leetcode-cn.com/problems/linked-list-cycle-ii
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        // 1、通过快慢指针的方式,在环中寻找它们的第一次相遇的节点位置

        // 2、定义一个慢指针,每次只会向前移动 1 步
        ListNode *slow = head;
        // 3、定义一个快指针,每次只会向前移动 2 步
        ListNode *fast = head;

        // 4、如果链表有环,那么无论怎么移动,fast 指向的节点都是有值的
        while (fast != NULL && fast->next != NULL) {
            // 慢指针每次只会向前移动 1 步
            slow = slow->next;
            // 快指针每次只会向前移动 2 步
            fast = fast->next->next;

            // 快慢指针相遇,说明有环
            // x 代表从头节点到环形入口节点的节点数(不包含头节点)
            // y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)
            // z 代表从第一次相遇节点到环形入口的节点数(不包含第一次相遇节点)
            // y + z 代表环的节点总数
            // 此时,快指针走了 x + y + n (y + z)
            // 其中,x + y 表示快指针第一次到达相遇节点,n 代表快指针在环里面绕了多少圈
            // 此时,慢指针走了 x + y 步

            // 由于快指针每次走 2 步,所以快慢指针第一次相遇的时候出现一个等式
            // x + y = [x + y + n (y + z)] / 2
            // 即 2 * (x + y) = x + y + n (y + z)
            // 即 x + y = n(y + z)
            // 即 x = n(y + z)- y
            // 我们的目的就是去求 x
            
            // 定义两个指针,一个指向相遇节点,定义为 b,一个指向链表头节点,定义为 a

            // b 在环中绕圈圈,走了 n(y + z)步会回到原处,即回到相遇节点处
            // 由于 y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)
            // 所以 n(y + z) - y 时,b 到达了环形入口节点位置

            // 由于 x 代表从头节点到环形入口节点的节点数(不包含头节点)
            // 所以 a 走了 x 步时,a 到达了环形入口节点位置

            // 当 x = n(y + z)- y 时,找到了环形入口节点位置

            // 5、开始寻找环入口
            if (slow == fast) {

                // 定义两个指针,一个指向相遇节点,定义为 b,一个指向链表头节点,定义为 a
                // 一个指向相遇节点,定义为 b
                ListNode *b = fast;

                // 一个指向链表头节点,定义为 a
                ListNode *a = head;

                // 让 a 、b 两个指针向前移动,每次移动一步,直到相遇位置
                // 由于有环,必然相遇
                // 当 b 走了 n(y + z) - y 时,b 到达了环形入口节点位置
                // 当 a 走了 x 步时,a 到达了环形入口节点位置
                // a 与 b 相遇
                while (a != b) {
                    // a 指针每次只会向前移动 1 步
                    a = a->next;
                    // b 指针每次只会向前移动 1 步
                    b = b->next;
                }

                // 6、返回 a 和 b 相遇的节点位置就是环形入口节点位置
                return a;
            }
        }

        // 没有环,返回 NULL
        return NULL;
    }
};

# 3、Python 代码

# 登录 AlgoMooc 官网获取更多算法图解
# https://www.algomooc.com
# 作者:程序员吴师兄
# 代码有看不懂的地方一定要私聊咨询吴师兄呀
# 环形链表 II ( LeetCode 142 ) : https://leetcode-cn.com/problems/linked-list-cycle-ii
class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        # 1、通过快慢指针的方式,在环中寻找它们的第一次相遇的节点位置

        # 2、定义一个慢指针,每次只会向前移动 1 步
        slow = head
        # 3、定义一个快指针,每次只会向前移动 2 步
        fast = head

        # 4、如果链表有环,那么无论怎么移动,fast 指向的节点都是有值的
        while fast != None and fast.next != None :
            # 慢指针每次只会向前移动 1 步
            slow = slow.next
            # 快指针每次只会向前移动 2 步
            fast = fast.next.next

            # 快慢指针相遇,说明有环
            # x 代表从头节点到环形入口节点的节点数(不包含头节点)
            # y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)
            # z 代表从第一次相遇节点到环形入口的节点数(不包含第一次相遇节点)
            # y + z 代表环的节点总数
            # 此时,快指针走了 x + y + n y + z)
            # 其中,x + y 表示快指针第一次到达相遇节点,n 代表快指针在环里面绕了多少圈
            # 此时,慢指针走了 x + y 步

            # 由于快指针每次走 2 步,所以快慢指针第一次相遇的时候出现一个等式
            # x + y = [x + y + n y + z)] / 2
            # 即 2 * x + y) = x + y + n y + z)
            # 即 x + y = n(y + z)
            # 即 x = n(y + z)- y
            # 我们的目的就是去求 x
            
            # 定义两个指针,一个指向相遇节点,定义为 b,一个指向链表头节点,定义为 a

            # b 在环中绕圈圈,走了 n(y + z)步会回到原处,即回到相遇节点处
            # 由于 y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)
            # 所以 n(y + z) - y 时,b 到达了环形入口节点位置

            # 由于 x 代表从头节点到环形入口节点的节点数(不包含头节点)
            # 所以 a 走了 x 步时,a 到达了环形入口节点位置

            # 当 x = n(y + z)- y 时,找到了环形入口节点位置

            # 5、开始寻找环入口
            if slow == fast :

                # 定义两个指针,一个指向相遇节点,定义为 b,一个指向链表头节点,定义为 a
                # 一个指向相遇节点,定义为 b
                b = fast

                # 一个指向链表头节点,定义为 a
                a = head

                # 让 a 、b 两个指针向前移动,每次移动一步,直到相遇位置
                # 由于有环,必然相遇
                # 当 b 走了 n(y + z) - y 时,b 到达了环形入口节点位置
                # 当 a 走了 x 步时,a 到达了环形入口节点位置
                # a 与 b 相遇
                while a != b :
                    # a 指针每次只会向前移动 1 步
                    a = a.next
                    # b 指针每次只会向前移动 1 步
                    b = b.next
                

                # 6、返回 a 和 b 相遇的节点位置就是环形入口节点位置
                return a
            
        # 没有环,返回 None
        return None

# 四、复杂度分析

时间复杂度:O(N),其中 NN 为链表中节点的数目。在最初判断快慢指针是否相遇时,slow 指针走过的距离不会超过链表的总长度;随后寻找入环点时,走过的距离也不会超过链表的总长度。因此,总的执行时间为 O(N)+O(N)=O(N)。

空间复杂度:O(1)。